import java.util.*;
/**
 * 环形链表入口检测
 * 给定一个链表，返回链表开始入环的第一个节点
 * 使用快慢指针（Floyd's Cycle-Finding Algorithm）实现
 */
public class detectCycle {
    /**
     * 链表节点类
     * 包含节点值和指向下一个节点的引用
     */
    public static class ListNode{
        int val;        // 节点值
        ListNode next;  // 指向下一个节点的引用
        
        // 无参构造函数
        ListNode(){}
        
        // 带值的构造函数
        ListNode(int val){
            this.val = val;
        }
        
        // 带值和下一个节点的构造函数
        ListNode(int val, ListNode next){
            this.val = val;
            this.next = next;
        }
    }

    // 刷题指导：
    // 先看可不可以借助外部结构解决问题，栈、队列、集合、map等
    // 遇事不决先抽象出一层
    // 看数学有没有类似的结构，奇数偶数，集合...
    // 分解问题
    
    // 1. 朴素做法，通过set无重复元素的特点记录链表节点(抽象、外部结构、集合)
    // 2. 快慢指针，慢指针1步，快指针2步(奇数偶数)
    // public static ListNode detectCycle(ListNode l){
    //     HashSet<ListNode> set = new HashSet<>();
    //     while(l != null){
    //         boolean flag = set.add(l);
    //         if(flag == false) return l;
    //         l = l.next;
    //     }
    //     return null;
    // }
    /**
     * 检测链表环的入口节点
     * 算法步骤：
     * 1. 使用快慢指针找到相遇点
     * 2. 从相遇点和头节点同时出发，相遇点即为环的入口
     * @param l 链表头节点
     * @return 环的入口节点，如果不存在环则返回null
     */
    public static ListNode detectCycleM(ListNode l){
        // 初始化快慢指针，都指向头节点
        ListNode slow = l;
        ListNode fast = l;
        
        // 使用快慢指针找到相遇点
        while(fast != null && fast.next != null){
            fast = fast.next.next;  // 快指针移动两步
            slow = slow.next;       // 慢指针移动一步
            
            // 如果快慢指针相遇，说明存在环
            if(fast == slow){
                // 从相遇点和头节点同时出发，找到环的入口
                ListNode p = l;
                while(p != slow){
                    slow = slow.next;
                    p = p.next;
                }
                return p;  // 返回环的入口节点
            }
        }
        return null;  // 如果不存在环，返回null
    }

    /**
     * 主函数：处理输入输出
     * 输入格式：
     * 第一行：链表节点值，用空格分隔
     * 第二行：环的起始位置（-1表示无环）
     */
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        // 读取链表节点值
        String[] s = sc.nextLine().split(" ");
        // 读取环的起始位置
        int pos = sc.nextInt();
        sc.nextLine();  // 消耗换行符
        
        // 创建虚拟头节点
        ListNode dummy = new ListNode(0);
        ListNode now = dummy;
        ListNode cyclePos = null;  // 用于记录环的起始位置
        
        // 使用HashMap记录每个节点对应的索引位置(外部结构、map)
        HashMap<ListNode, Integer> map = new HashMap<>(); 
        
        // 构建链表
        for(int i = 0; i < s.length; i++){
            now.next = new ListNode(Integer.parseInt(s[i]));
            now = now.next;
            map.put(now, i);  // 记录节点和索引的映射关系
            // 如果当前位置是环的起始位置，记录该节点
            if(i == pos){
                cyclePos = now;
            }
        }
        
        // 如果存在环，将最后一个节点指向环的起始位置
        if(pos != -1){
            now.next = cyclePos;
        }
        
        // 检测环的入口并输出其索引位置
        ListNode result = detectCycleM(dummy.next);
        System.out.println(map.get(result));
        sc.close();
    }
}
